package com.example.kotlinTest

/**
 * 更多语言结构
 * 1.解构声明
 * 2.类型检测与转换
 * 3.This表达式
 * 4.相等性
 * 5.操作符重载
 * 6.空安全
 * 7.异常
 * 8.注解
 * 9.反射
 * 10.序列化
 * 11.作用于函数
 * 12.类型安全的构建器
 * 13.选择加入要求
 */
class MoreLanguageStructure {

}

////////////////////////////////////////////////////////////解构声明
/**
 *
 * val (name,age) = person
 *
 * 一个解构声明会被编译成以下代码
 * val name  = person.component1()
 * val age = person.component2()
 *
 * 其中的 component1() 和 component2() 函数是在 Kotlin 中广泛使用的 约定原则 的另一个例
子。 （ 参见像 + 和 * 、 for -循环等操作符） 。 任何表达式都可以出现在解构声明的右
侧， 只要可以对它调用所需数量的 component 函数即可。 当然， 可以有 component3() 和
component4() 等等。
请注意， componentN() 函数需要用 operator 关键字标记， 以允许在解构声明中使用它们。
解构声明也可以用在 for -循环中： 当你写：
for ((a, b) in collection) { …… }
变量 a 和 b 的值取自对集合中的元素上调用 component1() 和 component2() 的返回值
 */

//例： 从函数中返回两个变量
/*
让我们假设我们需要从一个函数返回两个东西。 例如， 一个结果对象和一个某种状态。 在
Kotlin 中一个简洁的实现方式是声明一个数据类 并返回其实例：
 */
data class Result(val result: Int, val status: Int)
fun function(result: Int,status: Int): Result {
    // 各种计算
    return Result(result, status)
}
// 现在， 使用该函数：
//val (result, status) = function(1,1)
/**
因为数据类自动声明 componentN() 函数， 所以这里可以用解构声明。
注意： 我们也可以使用标准类 Pair 并且让 function() 返回 Pair<Int, Status> ， 但是让数
据合理命名通常更好
 */

/**
 * 例： 解构声明和映射
可能遍历一个映射（ map） 最好的方式就是这样：
for ((key, value) in map) {
// 使用该 key、 value 做些事情
}
为使其能用， 我们应该
通过提供一个 iterator() 函数将映射表示为一个值的序列；
通过提供函数 component1() 和 component2() 来将每个元素呈现为一对。
当然事实上， 标准库提供了这样的扩展：
operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> = entrySet().iterator
()
operator fun <K, V> Map.Entry<K, V>.component1() = getKey()
operator fun <K, V> Map.Entry<K, V>.component2() = getValue()
因此你可以在 for -循环中对映射（ 以及数据类实例的集合等） 自由使用解构声明。
 */


/**
下划线用于未使用的变量（ 自 1.1 起）
如果在解构声明中你不需要某个变量， 那么可以用下划线取代其名称：
val (_, status) = getResult()
对于以这种方式跳过的组件， 不会调用相应的 componentN() 操作符函数。
在 lambda 表达式中解构（ 自 1.1 起）
你可以对 lambda 表达式参数使用解构声明语法。 如果 lambda 表达式具有 Pair 类型（ 或者
Map.Entry 或任何其他具有相应 componentN 函数的类型） 的参数， 那么可以通过将它们放在
括号中来引入多个新参数来取代单个新参数：
map.mapValues { entry -> "${entry.value}!" }
map.mapValues { (key, value) -> "$value!" }
注意声明两个参数和声明一个解构对来取代单个参数之间的区别：
{ a //-> …… } // 一个参数
{ a, b //-> …… } // 两个参数
{ (a, b) //-> …… } // 一个解构对
{ (a, b), c //-> …… } // 一个解构对以及其他参数

如果解构的参数中的一个组件未使用， 那么可以将其替换为下划线， 以避免编造其名称：
map.mapValues { (_, value) -> "$value!" }
你可以指定整个解构的参数的类型或者分别指定特定组件的类型：
map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" }
map.mapValues { (_, value: String) -> "$value!" }
 */

///////////////////////////////////////////////////////////////类型检测与转换
/**
 * 类型检测与类型转换： “is”与“as”
 * is 与 !is 操作符
我们可以在运行时通过使用 is 操作符或其否定形式 !is 来检测对象是否符合给定类型：
if (obj is String) {
print(obj.length)
}
if (obj !is String) { // 与 !(obj is String) 相同
print("Not a String")
} else {
print(obj.length)
}
 */

/**
 * 智能转换
在许多情况下， 不需要在 Kotlin 中使用显式转换操作符， 因为编译器跟踪不可变值的 is -检
测以及显式转换， 并在需要时自动插入（ 安全的） 转换：
fun demo(x: Any) {
    if (x is String) {
    print(x.length) // x 自动转换为字符串
    }
}

编译器足够聪明， 能够知道如果反向检测导致返回那么该转换是安全的：
if (x !is String) return
print(x.length) // x 自动转换为字符串

或者在 && 和 || 的右侧：
// `||` 右侧的 x 自动转换为字符串
if (x !is String || x.length == 0) return
// `&&` 右侧的 x 自动转换为字符串
if (x is String && x.length > 0) {
    print(x.length) // x 自动转换为字符串
}

这些 智能转换 用于 when -表达式 和 while -循环 也一样：
when (x) {
    is Int -> print(x + 1)
    is String -> print(x.length + 1)
    is IntArray -> print(x.sum())
}
请注意， 当编译器不能保证变量在检测和使用之间不可改变时， 智能转换不能用。 更具体
地， 智能转换能否适用根据以下规则：
val 局部变量——总是可以， 局部委托属性除外；
val 属性——如果属性是 private 或 internal， 或者该检测在声明属性的同一模块中执行。
智能转换不适用于 open 的属性或者具有自定义 getter 的属性；
var 局部变量——如果变量在检测和使用之间没有修改、 没有在会修改它的 lambda 中捕
获、 并且不是局部委托属性；
var 属性——决不可能（ 因为该变量可以随时被其他代码修改） 。
 */

/**
 * “不安全的”转换操作符
 * 通常， 如果转换是不可能的， 转换操作符会抛出一个异常。 因此， 我们称之为不安全的。
Kotlin 中的不安全转换由中缀操作符 as （ 参见operator precedence） 完成：
val x: String = y as String

请注意， null 不能转换为 String 因该类型不是可空的， 即如果 y 为空， 上面的代码会抛
出一个异常。 为了让这样的代码用于可空值， 请在类型转换的右侧使用可空类型：
val x: String? = y as String?
 */

/**
 * “安全的”（ 可空） 转换操作符
为了避免抛出异常， 可以使用安全转换操作符 as? ， 它可以在失败时返回 null ：
val x: String? = y as? String
请注意， 尽管事实上 as? 的右边是一个非空类型的 String ， 但是其转换的结果是可空的。
 */

/**
 * 类型擦除与泛型检测
 * Kotlin 在编译时确保涉及泛型操作的类型安全性， 而在运行时， 泛型类型的实例并未带有关于
它们实际类型参数的信息。 例如， List<Foo> 会被擦除为 List<*> 。 通常， 在运行时无法检
测一个实例是否属于带有某个类型参数的泛型类型。
为此， 编译器会禁止由于类型擦除而无法执行的 is 检测， 例如 ints is List<Int> 或者
list is T （ 类型参数） 。 当然， 你可以对一个实例检测星投影的类型：
if (something is List<*>) {
something.forEach { println(it) } // 这些项的类型都是 `Any?`
}
类似地， 当已经让一个实例的类型参数（ 在编译期） 静态检测， 就可以对涉及非泛型部分做
is 检测或者类型转换。 请注意， 在这种情况下， 会省略尖括号：
fun handleStrings(list: List<String>) {
    if (list is ArrayList) {
    // `list` 会智能转换为 `ArrayList<String>`
    }
}

省略类型参数的这种语法可用于不考虑类型参数的类型转换： list as ArrayList 。
带有具体化的类型参数的内联函数使其类型实参在每个调用处内联， 这就能够对类型参数进
行 arg is T 检测， 但是如果 arg 自身是一个泛型实例， 其类型参数还是会被擦除。 例如：
//sampleStart
inline fun <reified A, reified B> Pair<*, *>.asPairOf(): Pair<A, B>? {
if (first !is A || second !is B) return null
    return first as A to second as B
}
val somePair: Pair<Any?, Any?> = "items" to listOf(1, 2, 3)
val stringToSomething = somePair.asPairOf<String, Any>()
val stringToInt = somePair.asPairOf<String, Int>()
val stringToList = somePair.asPairOf<String, List<*>>()
val stringToStringList = somePair.asPairOf<String, List<String>>() // 破坏类型安全！
//sampleEnd

fun main() {
    println("stringToSomething = " + stringToSomething)
    println("stringToInt = " + stringToInt)
    println("stringToList = " + stringToList)
    println("stringToStringList = " + stringToStringList)
}

非受检类型转换
如上所述， 类型擦除使运行时不可能对泛型类型实例的类型实参进行检测， 并且代码中的泛
型可能相互连接不够紧密， 以致于编译器无法确保类型安全。
即便如此， 有时候我们有高级的程序逻辑来暗示类型安全。 例如：
fun readDictionary(file: File): Map<String, *> = file.inputStream().use {
TODO("Read a mapping of strings to arbitrary elements.")
}
// 我们已将存有一些 `Int` 的映射保存到该文件
val intsFile = File("ints.dictionary")
// Warning: Unchecked cast: `Map<String, *>` to `Map<String, Int>`
val intsDictionary: Map<String, Int> = readDictionary(intsFile) as Map<String, Int>
编译器会对最后一行的类型转换产生一个警告。 该类型转换不能在运行时完全检测， 并且不
能保证映射中的值是“Int”。
为避免未受检类型转换， 可以重新设计程序结构： 在上例中， 可以使用具有类型安全实现的
不同接口 DictionaryReader<T> 与 DictionaryWriter<T> 。 可以引入合理的抽象， 将未受检的
类型转换从调用代码移动到实现细节中。 正确使用泛型型变也有帮助。
对于泛型函数， 使用具体化的类型参数可以使诸如 arg as T 这样的类型转换受检， 除非
arg 对应类型的自身类型参数已被擦除。
可以通过在产生警告的语句或声明上用注解 @Suppress("UNCHECKED_CAST") 标注来禁止未受检
类型转换警告：
inline fun <reified T> List<*>.asListOfType(): List<T>? =
if (all { it is T })
@Suppress("UNCHECKED_CAST")
this as List<T> else
null

在 JVM 平台中， 数组类型（ Array<Foo> ） 会保留关于其元素被擦除类型的信息， 并且类型转
换为一个数组类型可以部分受检： 元素类型的可空性与类型实参仍然会被擦除。 例如， 如果
foo 是一个保存了任何 List<*> （ 无论可不可空） 的数组的话， 类型转换 foo as
Array<List<String>?> 都会成功。
 */

/////////////////////////////////////////////////////////////////////* 3.This表达式
/**
 * This 表达式
为了表示当前的 接收者 我们使用 this 表达式：
在类的成员中， this 指的是该类的当前对象。
在扩展函数或者带有接收者的函数字面值中， this 表示在点左侧传递的 接收者 参数。
如果 this 没有限定符， 它指的是最内层的包含它的作用域。 要引用其他作用域中的
this ， 请使用 标签限定符：

限定的 this
要访问来自外部作用域的 this （ 一个类 或者扩展函数， 或者带标签的带有接收者的函数字
面值） 我们使用 this@label ， 其中 @label 是一个代指 this 来源的标签：
class A { // 隐式标签 @A
    inner class B { // 隐式标签 @B
        fun Int.foo() { // 隐式标签 @foo
            val a = this@A // A 的 this
            val b = this@B // B 的 this
            val c = this // foo() 的接收者， 一个 Int
            val c1 = this@foo // foo() 的接收者， 一个 Int
            val funLit = lambda@ fun String.() {
            val d = this // funLit 的接收者
            }
            val funLit2 = { s: String ->
            // foo() 的接收者， 因为它包含的 lambda 表达式
            // 没有任何接收者
            val d1 = this
            }
        }
    }
}
 */
/**
 *Implicit this
 * 当对 this 调用成员函数时， 可以省略 this. 部分。 但是如果有一个同名的非成员函数时，
请谨慎使用， 因为在某些情况下会调用同名的非成员：
fun main() {
//sampleStart
fun printLine() { println("Top-level function") }
class A {
fun printLine() { println("Member function") }
fun invokePrintLine(omitThis: Boolean = false) {
if (omitThis) printLine()
else this.printLine()
}
} A
().invokePrintLine() // Member function
A().invokePrintLine(omitThis = true) // Top-level function
//sampleEnd()
}
 */

/////////////////////////////////////////////////////////////////////* 4.相等性
/**
 * 相等性
Kotlin 中有两种类型的相等性：
结构相等（ 用 equals() 检测） ；
引用相等（ 两个引用指向同一对象）
 */

/**
 *
 */
/////////////////////////////////////////////////////////////////////* 5.操作符重载
/////////////////////////////////////////////////////////////////////* 6.空安全
/////////////////////////////////////////////////////////////////////* 7.异常
/////////////////////////////////////////////////////////////////////* 8.注解
/////////////////////////////////////////////////////////////////////* 9.反射
/////////////////////////////////////////////////////////////////////* 10.序列化
/////////////////////////////////////////////////////////////////////* 11.作用于函数
/////////////////////////////////////////////////////////////////////* 12.类型安全的构建器
/////////////////////////////////////////////////////////////////////* 13.选择加入要求













